package com.ks.phone.manager;

import android.os.Environment;
import android.os.SystemClock;
import android.util.Log;

import com.ks.phone.provider.ContextGlobal;
import com.ks.phone.utils.PreferencesUtils;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;
import java.text.SimpleDateFormat;
import java.util.Arrays;
import java.util.Comparator;
import java.util.Date;
import java.util.Locale;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * author 康少
 * date 2023/11/22
 * desc Logcat 日志存放本地文件
 * 　　　　　　　　┏┓　　　┏┓
 * 　　　　　　　┏┛┻━━━┛┻┓
 * 　　　　　　　┃　　　　　　  ┃
 * 　　　　　　　┃　　　━ 　　　┃
 * 　　　　　　　┃　＞　　　＜　┃
 * 　　　　　　　┃　　　　　　　┃
 * 　　　　　　　┃ ...　⌒　... ┃
 * 　　　　　　　┃　　　　　　　┃
 * 　　　　　　　 ┗━┓　　　 ┏━┛
 * 　　　　　　　　　┃　　　┃　Code is far away from bug with the animal protecting
 * 　　　　　　　　　┃　　　┃   神兽保佑,代码无bug
 * 　　　　　　　　　┃　　　┃
 * 　　　　　　　　　┃　　　┃
 * 　　　　　　　　　┃　　　┃
 * 　　　　　　　　　┃　　　┃
 * 　　　　　　　　　┃　　　┗━━━┓
 * 　　　　　　　　　┃　　　　　　　┣┓
 * 　　　　　　　　　┃　　　　　　　┏┛
 * 　　　　　　　　　┗┓┓┏━┳┓┏┛
 * 　　　　　　　　　　┃┫┫　┃┫┫
 * 　　　　　　　　　　┗┻┛　┗┻┛
 */
public class LogcatFileManager {
    private static final String TAG = LogcatFileManager.class.getSimpleName();
    private static final int MAX_FILE_COUNT = 5;//最多存储的日志文件数量
    private static final long MAX_FILE_SIZE = 128 * 1024 * 1024; // 每个日志文件限制大小
    public static final File logcatDir = new File(ContextGlobal.get().getApplicationContext().getExternalFilesDir(null), "LogcatFiles");
    private static final AtomicBoolean isWriting = new AtomicBoolean(false);

    public static void startLogcat() {
        new Thread(() -> {
            // 只有日志开关打开时才存储日志到文件
            while (true) {
                // 循环检查确保logcat存储到文件
                if (!isWriting.get()) {
                    saveLogcatToFile(); // 保存logcat到文件
                }
                SystemClock.sleep(5 * 1000);
            }
        }).start();
    }

    private static void saveLogcatToFile() {
        try {
            // 创建logcat文件
            File logcatFile = createLogFile();
            if (logcatFile == null) {
                Log.e(TAG, "创建logcat文件失败");
                return;
            }

            // 执行logcat命令并且输出到文件
            String command = "logcat -v threadtime " + ContextGlobal.get().getApplicationContext().getPackageName() + ":*";
            Process process = Runtime.getRuntime().exec(command);
            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
            String line;
            long fileSize = 0;
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(Files.newOutputStream(logcatFile.toPath()), StandardCharsets.UTF_8));

            while ((line = reader.readLine()) != null) {
                isWriting.set(true);
                writer.write(line);
                writer.newLine();
                fileSize += line.length();

                if (fileSize >= MAX_FILE_SIZE) {
                    writer.close();

                    // 创建新的logcat文件
                    logcatFile = createLogFile();
                    if (logcatFile == null) {
                        Log.e(TAG, "创建logcat文件失败");
                        return;
                    }

                    writer = new BufferedWriter(new OutputStreamWriter(Files.newOutputStream(logcatFile.toPath()), StandardCharsets.UTF_8));
                    fileSize = 0;
                }
            }
            writer.close();
            isWriting.set(false);
        } catch (IOException e) {
            Log.e(TAG, "保存logcat到文件失败: " + e.getMessage());
            isWriting.set(false);
        }
    }

    private static File createLogFile() {
        String timeStamp = new SimpleDateFormat("yyyy_MM_dd_HH_mm_ss", Locale.CHINA).format(new Date());
        String fileName = "log_" + timeStamp + ".txt";
        File logcatFile;
        if (isExternalStorageWritable()) {
            if (!logcatDir.exists()) {
                if (!logcatDir.mkdirs()) {
                    Log.e(TAG, "创建logcat目录失败");
                    return null;
                }
            }

            logcatFile = new File(logcatDir, fileName);
            Log.d(TAG, "创建文件成功：" + logcatFile.getAbsolutePath());

            // 管理logcat文件
            manageLogcatFiles();
        } else {
            Log.e(TAG, "外部存储不可用");
            return null;
        }

        return logcatFile;
    }

    private static void manageLogcatFiles() {
        if (isExternalStorageWritable()) {
            File logcatDir = new File(ContextGlobal.get().getApplicationContext().getExternalFilesDir(null), "LogcatFiles");
            File[] logcatFiles = logcatDir.listFiles();

            if (logcatFiles != null && logcatFiles.length > MAX_FILE_COUNT) {
                Arrays.sort(logcatFiles, Comparator.comparingLong(File::lastModified));

                for (int i = 0; i < logcatFiles.length - MAX_FILE_COUNT; i++) {
                    String absolutePath = logcatFiles[i].getAbsolutePath();
                    boolean delete = logcatFiles[i].delete();
                    Log.e(TAG, "删除文件 " + delete + " : = " + absolutePath);
                }
            }
        } else {
            Log.e(TAG, "外部存储不可用");
        }
    }

    private static boolean isExternalStorageWritable() {
        String state = Environment.getExternalStorageState();
        return Environment.MEDIA_MOUNTED.equals(state);
    }
}
